#include <bits/stdc++.h>
using namespace std;

// 本算法使用穷举法，这个方法可以通过 30% 的用例，其余用例超时了。
// 要想 100% 通过，应该使用效率更高的算法。

// 可以考虑用循环提高速度
// for(long long i = 0; i < n; i++) {
//     for(long long j = 0; j < n; j++) {
//         if (j == i) continue;

//          for(k = 0; k < n; k++) {
//             if (k == j || k == i) continue;

//             // (i, j, k)
//             // 计算 S
//             // 同时考虑 S 的最大值
//          }
//     }
// }

// 本题用 DFS 
// 对本题用穷举法本质上就是从集合 A = {H_i}中，仍选 3 个元素计算 S 值
// 得到集合 S = {s_i}，求 max{s_i}



long long n;
long long H[1000000]; // H[0:n]
long long t[3]; // 记录选择的三个 H_i作为 H_a, H_b, H_c

// 读取数据
void ReadData() 
{
    cin>>n;
    for(long long i=0;i<n;i++)
    {
        cin>>H[i];
    }
}

// gcd2 求两个参数 a, b 的最大公约数
long long gcd2(long long a,long long b)
{
    if(b==0)
    {
        return a;
    }
    return gcd2(b,(a%b));
}

// lcm2 两个参数 a, b 的最小公倍数
long long lcm2(long long a,long long b)
{
    return (a/gcd2(a,b))*b;
}

// lcm3 三个参数的 a, b, c 的最小公倍数
long long lcm3(long long a,long long b,long long c)
{
    return (lcm2(a,b)/gcd2(lcm2(a,b),c))*c;
}

// dfs 用到的全局数据再声明一下，便于理解程序
extern long long n;
extern long long H[1000000]; // H[0:n]
extern long long t[3]; // 记录选择的三个 H_i作为 H_a, H_b, H_c
// dfs 函数从数组 H[1000000] 中任选 3 个数放入 t[] 成为 Ha, Hb, Hc
// 选够了就计算 S 值
// n, H[], t[] 没有必要作为 dfs 函数的参数，只需要将目前选择 H[] 的第 i_H 位置的元素以及 t[] 放置的位置为 i_t 作为参数即可。这样可以简化函数
long long S_max = 0; // 记录计算出的 max{S_i}
long long h[3]; // 记录取得 S_max 时的 Ha, Hb, Hc
void dfs(long long i_H, long long i_t)
{
    if(i_H==n||i_t==3)
    {
        if(i_t==3)
        {//选够了 3 个元素，计算 S 值，并判断其是否比之前算出来的 S_max 大，记录目前为止最大的 S_max
            long long Ha = t[0],
                      Hb = t[1],
                      Hc = t[2];
            long long S = Ha * Hb * Hc*lcm3(Ha, Hb, Hc)/lcm2(Ha, Hb)/lcm2(Ha, Hc)/lcm2(Hb,Hc);
            if(S > S_max) 
            { // 记录结果
                S_max = S;
                h[0] = Ha;
                h[1] = Hb;
                h[2] = Hc;
            }
        }
        return;
    }

    // 目前从 H[i_H:n] 剩余元素中取出最前面的 H[i_H]，并分别考虑是否将其加入 t[:i_t] 的尾部
    t[i_t] = H[i_H];
    dfs(i_H+1, i_t + 1); // 将 H[i_H] 加入 t[] 内 
    dfs(i_H+1, i_t); // 不讲 H[i_H] 加入 t[] 内
}

int main()
{
    ReadData();

    // 对 H 升序排序
    std::sort(H, H+n);

    // 用 dfs 计算
    dfs(0 ,0);
    
    // 输出结果
    cout<< h[0] <<" "<< h[1] <<" "<< h[2];
    return 0;
}